Internet Surfer 2.0

home *** CD-ROM | disk | FTP | other *** search

/ Internet Surfer 2.0 / Internet Surfer 2.0 (Wayzata Technology) (1996).iso / pc / text / mac / faqs.351 < prev next >

Wrap

Text File | 1996-02-12 | 28.0 KB | 627 lines

Frequently Asked Questions (FAQS);faqs.351 ANSWER: You have an old version of Emacs compiled before GCC 2.11c and you are using the Linux extended filesystem. Get the new version. QUESTION: Why doesn't Control-Z doesn't work right with Emacs? QUESTION: Why doesn't job control work in shell mode? ANSWER: You have a really old version of Linux Emacs. Get the new one. ===================8<==========>8================ -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # LaBRI | # # 351 cours de la Liberation | e-mail: corsini@labri.greco-prog.fr # # 33405 Talence Cedex | # # | # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- There will be some sig, once our local net will be reliable. Right now I rather stay anonymous. Xref: bloom-picayune.mit.edu comp.lang.lisp:8749 news.answers:4559 Path: bloom-picayune.mit.edu!enterpoop.mit.edu!spool.mu.edu!uunet!ogicse!das-news.harvard.edu!cantaloupe.srv.cs.cmu.edu!crabapple.srv.cs.cmu.edu!mkant From: mkant+@cs.cmu.edu (Mark Kantrowitz) Newsgroups: comp.lang.lisp,news.answers Subject: FAQ: Lisp Frequently Asked Questions 1/6 [Monthly posting] Summary: Introductory Matter and Bibliography of Introductions and References Message-ID: <lisp-faq-1.text_724237235@cs.cmu.edu> Date: 13 Dec 92 09:01:07 GMT Article-I.D.: cs.lisp-faq-1.text_724237235 Expires: Tue, 26 Jan 1993 09:00:35 GMT Sender: news@cs.cmu.edu (Usenet News System) Reply-To: lisp-faq@think.com Followup-To: poster Organization: School of Computer Science, Carnegie Mellon Lines: 1231 Approved: news-answers-request@MIT.Edu Supersedes: <lisp-faq-1.text_721645282@cs.cmu.edu> Nntp-Posting-Host: a.gp.cs.cmu.edu Archive-name: lisp-faq/part1 Last-Modified: Thu Nov 5 19:30:40 1992 by Mark Kantrowitz Version: 1.27 ;;; **************************************************************** ;;; Answers to Frequently Asked Questions about Lisp *************** ;;; **************************************************************** ;;; Written by Mark Kantrowitz and Barry Margolin ;;; lisp-faq-1.text -- 60654 bytes This post contains Part 1 of the Lisp FAQ. If you think of questions that are appropriate for this FAQ, or would like to improve an answer, please send email to us at lisp-faq@think.com. Note that the lisp-faq mailing list is for discussion of the content of the FAQ posting only. It is not the place to ask questions about Lisp; use either the common-lisp@ai.sri.com mailing list or the comp.lang.lisp newsgroup for that. If a question appears frequently in one of those forums, it will get added to the FAQ list. There are currently six parts to the Lisp FAQ: 1. Introductory Matter and Bibliography of Introductions and References 2. General Questions 3. Common Programming Pitfalls 4. Lisp/Scheme Implementations and Mailing Lists 5. CLOS and PCL Questions 6. FTP Archives and Resources All parts are posted to comp.lang.lisp. Part 4 is cross-posted to the comp.lang.scheme newsgroup. Part 5 is cross-posted to the comp.lang.clos newsgroup. Topics Covered (Part 1): [1-0] What is the purpose of this newsgroup? [1-1] What documentation is available on Lisp? How can I learn Lisp? [1-2] How can I improve my Lisp programming style and coding efficiency? [1-3] Where can I learn about implementing Lisp interpreters and compilers? [1-4] What does CLOS, PCL, X3J13, CAR, CDR, ... mean? [1-5] Where can I get a copy of the draft ANSI standard for Common Lisp? [1-6] Lisp Job Postings Topics Covered (Part 2): [2-1] Is there a GNU-Emacs interface to Lisp? [2-3] What is the equivalent of EXPLODE and IMPLODE in Common Lisp? [2-4] Is Lisp inherently slower than more conventional languages such as C? [2-5] Why does Common Lisp have "#'"? [2-6] How do I call non-Lisp functions from Lisp? [2-7] Can I call Lisp functions from other languages? [2-8] I want to call a function in a package that might not exist at compile time. How do I do this? [2-9] What is CDR-coding? [2-10] What is garbage collection? [2-11] How do I save an executable image of my loaded Lisp system? How do I run a Unix command in my Lisp? How do I get the current directory name from within a Lisp program? [2-12] I'm porting some code from a Symbolics Lisp machine to some other platform, and there are strange characters in the code. What do they mean? [2-13] History: Where did Lisp come from? [2-14] How do I find the argument list of a function? How do I get the function name from a function object? [2-15] How can I have two Lisp processes communicate via unix sockets? Common Pitfalls (Part 3): [3-0] Why does (READ-FROM-STRING "foobar" :START 3) return FOOBAR instead of BAR? [3-1] Why can't it deduce from (READ-FROM-STRING "foobar" :START 3) that the intent is to specify the START keyword parameter rather than the EOF-ERROR-P and EOF-VALUE optional parameters? [3-2] Why can't I apply #'AND and #'OR? [3-3] I used a destructive function (e.g. DELETE, SORT), but it didn't seem to work. Why? [3-4] After I NREVERSE a list, it's only one element long. After I SORT a list, it's missing things. What happened? [3-5] Why does (READ-LINE) return "" immediately instead of waiting for me to type a line? [3-6] I typed a form to the read-eval-print loop, but nothing happened. Why? [3-7] DEFMACRO doesn't seem to work. When I compile my file, LISP warns me that my macros are undefined functions, or complains "Attempt to call <function> which is defined as a macro. [3-8] Name conflict errors are driving me crazy! (EXPORT, packages) [3-9] Closures don't seem to work properly when referring to the iteration variable in DOLIST, DOTIMES and DO. [3-10] What is the difference between FUNCALL and APPLY? [3-11] Miscellaneous things to consider when debugging code. [3-12] When is it right to use EVAL? [3-13] Why does my program's behavior change each time I use it? [3-14] When producing formatted output in Lisp, where should you put the newlines (e.g., before or after the line, FRESH-LINE vs TERPRI, ~& vs ~% in FORMAT)? [3-15] I'm using DO to do some iteration, but it doesn't terminate. Lisp/Scheme Implementations and Mailing Lists (Part 4): [4-0] Free Lisp implementations. [4-1] Commercial Lisp implementations. [4-2] Free Scheme implementations. [4-3] Commercial Scheme implementations. [4-4] Other Commercial Lisp-like Language implementations. [4-5] Where can I get an implementation of Prolog in Lisp? [4-6] What is Dylan? [4-7] What Lisp-related discussion groups and mailing lists exist? [4-8] What are R4RS and IEEE P1178? [4-9] How do I do object-oriented programming in Scheme? CLOS Questions (Part 5): [5-0] What is CLOS (PCL) and where can I get it? How do you pronounce CLOS? [5-1] What documentation is available about object-oriented programming in Lisp? [5-2] How I write a function that can access defstruct slots by name? I would like to write something like (STRUCTURE-SLOT <object> '<slot-name>). [5-3] How can I list all the CLOS instances in a class? [5-4] How can I store data and CLOS instances (with possibly circular references) on disk so that they may be retrieved at some later time? [5-5] Given the name of a class, how can I get the names of its slots? FTP Resources (Part 6): [6-0] General information about FTP Resources for Lisp and Scheme [6-1] Repositories of Lisp Software [6-2] Repositories of Scheme Software [6-3] Publicly Redistributable Lisp Software [6-4] Publicly Redistributable Scheme Software [6-5] How can I use the X Window System or other GUIs from Lisp? [6-6] Formatting code in LaTeX Search for [#] to get to question number # quickly. Introduction: Certain questions and topics come up frequently in the various network discussion groups devoted to and related to Lisp. This file/article is an attempt to gather these questions and their answers into a convenient reference for Lisp programmers. It (or a reference to it) is posted periodically. The hope is that this will cut down on the user time and network bandwidth used to post, read and respond to the same questions over and over, as well as providing education by answering questions some readers may not even have thought to ask. This is not a Lisp tutorial, nor is it an exhaustive list of all Lisp intricacies. Lisp is a very powerful and expressive language, but with that power comes many complexities. This list attempts to address the ones that average Lisp programmers are likely to encounter. If you are new to Lisp, see the answer to the question "How can I learn Lisp?". The latest version of this file is available via anonymous FTP from CMU and Thinking Machines: To obtain the files from CMU, connect by anonymous ftp to any CMU CS machine (e.g., ftp.cs.cmu.edu [128.2.206.173]), using username "anonymous" and password "name@host". The files lisp-faq-1.text, lisp-faq-2.text, lisp-faq-3.text, lisp-faq-4.text, lisp-faq-5.text and lisp-faq-6.text are located in the directory /afs/cs.cmu.edu/user/mkant/Public/Lisp-Utilities/ [Note: You must cd to this directory in one atomic operation, as some of the superior directories on the path are protected from access by anonymous ftp.] If your site runs the Andrew File System, you can just cp the files directly without bothering with FTP. To obtain the files from Thinking Machines, ftp them from ftp.think.com, in the directory /public/think/lisp/. The file faq.text contains all the parts of the FAQ in one file. In addition, specific versions of the FAQ are available as faq-<version>.text. Unless otherwise specified, the Lisp dialect referred to is Common Lisp, as defined by "Common Lisp: the Language" (aka "CLtL1") as well as corrections (but not enhancements) from "Common Lisp: the Language, 2nd Edition" (aka "CLtL2"), both by Guy L. Steele, Jr. and published by Digital Press. Note that CLtL2 is NOT an official specification for the language; ANSI Committee X3J13 is preparing such a specification. See question [1-5] for information on the status of the ANSI specification for Common Lisp. Enhancements such as CLOS, conditions, and the LOOP macro will be referred to separately. ---------------------------------------------------------------- [1-0] What is the purpose of this newsgroup? The newsgroup comp.lang.lisp exists for general discussion of topics related to the programming language Lisp. For example, possible topics can include (but are not necessarily limited to): announcements of Lisp books and products discussion of programs and utilities written in Lisp discussion of portability issues questions about possible bugs in Lisp implementations problems porting an implementation to some architecture Postings should be of general interest to the Lisp community. See also question [4-7]. Questions about object oriented programming in Lisp should be directed to the newsgroup comp.lang.clos. Similarly, questions about the programming language Scheme should be directed to the newsgroup comp.lang.scheme. Discussion of functional programming language issues should be directed to the newsgroup comp.lang.functional. Discussion of AI programs implemented in Lisp should sometimes be cross-posted to the newsgroup comp.ai. ---------------------------------------------------------------- [1-1] What documentation is available on Lisp? How can I learn Lisp? There are several good Lisp introductions and tutorials: 1. David S. Touretzky "Common Lisp: A Gentle Introduction to Symbolic Computation" Benjamin/Cummings Publishers, 1990. 384 pages. Perhaps the best tutorial introduction to the language. It has clear and correct explanations, and covers some fairly advanced topics. The book is an updated Common Lisp version of the 1984 edition published by Harper and Row Publishers. Three free Lisp educational tools which were used in the book -- Evaltrace, DTRACE and SDRAW -- are available by anonymous ftp from b.gp.cs.cmu.edu:/usr/dst/public/{lisp,evaltrace}. Evaltrace is a graphical notation for explaining how evaluation works and is described in "Visualizing Evaluation in Applicative Languages" by David S. Touretzky and Peter Lee, CACM 45-59, October 1992. DTRACE is a "detailed trace" which provides more information than the tracing tools provided with most Common Lisp implementations. SDRAW is a program that draws cons cell structures both for X11 and ascii terminals. 2. Robert Wilensky "Common LISPcraft" W. W. Norton, 1986. 385 pages. 3. Wade L. Hennessey "Common Lisp" McGraw-Hill, 1989. 395 pages. Fairly good, but jumps back and forth from the simple to the complex rather quickly, with no clear progression in difficulty. 4. Laurent Siklossy "Let's Talk LISP" Prentice-Hall, NJ, 1976. 237 pages. Good introduction, but quite out of date. 5. Stuart C. Shapiro "Common Lisp: An Interactive Approach" Computer Science Press/W.H. Freeman, New York, 1992. ISBN 0-7167-8218-9 Other introductions to Lisp include: 1. A. A. Berk. "LISP, The Language of Artificial Intelligence" Van Nostrand Reinhold, 1985. 160 pages. 2. Paul Y. Gloess. "An Alfred handy guide to Understanding LISP" Alfred Publishers (Sherman Oaks, CA), 1982. 64 pages. 3. Ward D. Maurer. "The Programmer's Introduction to LISP" American Elsevier, 1972. 112 pages. 4. Hank Bromley and Richard Lamson. "LISP Lore: A Guide to Programming the LISP Machine" Kluwer Academic (Boston), 1987. 337 pages. 5. Sharam Hekmatpour. "Introduction to LISP and Symbol Manipulation" Prentice Hall (New York), 1988. 303 pages. 6. Deborah G. Tatar "A programmer's guide to Common Lisp" Digital Press, 1987. 327 pages. ISBN 0-932376-87-8. Good introduction on Common Lisp. 7. Timothy Koschmann "The Common Lisp Companion" John Wiley & Sons, 1990. Targeted for those with some programming experience who wish to learn draft-ANSI Common Lisp, including CLOS and the CL condition system. Examples progress incrementally from simple numerical calculation all the way to a logic-programming extension to CL. More advanced introductions to Lisp and its use in Artificial Intelligence include: 1. Peter Norvig. "Paradigms of AI Programming: Case Studies in Common Lisp" Morgan Kaufmann, 1992. 946 pages. ISBN 1-55860-191-0. Provides an in-depth exposition of advanced AI programming techniques and includes large-scale detailed examples. The book is the most advanced AI/Common-Lisp programming text and reference currently available, and hence is not for the complete novice. It focuses on the programming techniques necessary for building large AI systems, including object-oriented programming, and has a strong performance orientation. The text is marked by its use of "non-toy" examples to illustrate the techniques. All of the examples are written in Common Lisp, and copies of the source code are available by anonymous ftp from unix.sri.com:pub/norvig and on disk in Macintosh or DOS format from the publisher. Some of the techniques described include rule-based pattern matching (GPS, Eliza, a subset of Macsyma, the Emycin expert system shell), constraint propagation and backtracking (Waltz line-labelling), alpha-beta search (Othello), natural language processing (top-down, bottom-up and chart parsing), logic-programming (unification and Prolog), interpreters and compilers for Scheme, and object-oriented programming (CLOS). The examples are also used to illustrate good programming style and efficiency. There is a guide to trouble-shooting and debugging Lisp programs, a style guide, and a discussion of portability problems. Some of the efficiency techniques described include memoization, data indexing, compilation, delaying computation, proper use of declarations, avoiding garbage collection, and choosing and using the correct data structure. The book also serves as an advanced introduction to Common Lisp, with sections on the Loop macro, CLOS and sequences, and some coverage of error handling, series, and the package facility. 2. Eugene Charniak, Christopher K. Riesbeck, Drew V. McDermott and James R. Meehan. "Artificial Intelligence Programming", 2nd edition. Lawrence Erlbaum Associates (Hillsdale, NJ), 1987. 533 pages. Provides many nice code fragments, all of which are written in Common Lisp. The first half of the book covers topics like macros, the reader, data structures, control structures, and defstructs. The second half of the book describes programming techniques specific to AI, such as discrimination nets, production systems, deductive database retrieval, logic programming, and truth maintenance. 3. Patrick H. Winston and Berthold K. P. Horn. "LISP", 3rd edition. Addison-Wesley (Reading, MA), 1989. 611 pages. ISBN 0-201-08319-1 Covers the basic concepts of the language, but also gives a lot of detail about programming AI topics such as rule-based expert systems, forward chaining, interpreting transition trees, compiling transition trees and finding patterns in images. Not a tutorial. Has many good examples. 4. Rodney A. Brooks. "Programming in Common Lisp" Wiley, 1985. 303 pages. 5. John R. Anderson, Albert T. Corbett, and Brian J. Reiser. "Essential LISP" Addison-Wesley (Reading, MA), 1987. 352 pages. Concentrates on how to use Lisp with iteration and recursion. 6. Robert D. Cameron and Anthony H. Dixon "Symbolic Computing with Lisp" Prentice-Hall, 1992, 326 pages. ISBN 0-13-877846-9. The book is intended primarily as a third-year computer science text. In terms of programming techniques, it emphasizes recursion and induction, data abstraction, grammar-based definition of Lisp data structures and functional programming style. It uses two Lisp languages: (1) a purely functional subset of Lisp called Small Lisp and (2) Common Lisp. An MS-DOS interpreter for Small Lisp (including source) is provided with the book. It considers applications of Lisp to formal symbolic data domains: algebraic expressions, logical formulas, grammars and programming languages. 7. Hasemer and Domingue. "Common Lisp Programming for Artificial Intelligence" Addison-Wesley, 1989. 8. Steven Tanimoto "The Elements of Artificial Intelligence: An Introduction Using Lisp" Computer Science Press, Rockville, MD, 1987, 530 pages. 9. Patrick R. Harrison "Common Lisp and Artificial Intelligence" Prentice Hall, 1990. ISBN 0-13-155243 10. Rajeev Sangal "Programming Paradigms in Lisp" McGraw-Hill, 1991. ISBN 0-07-054666-5. General Lisp reference books include: 1. Guy L. Steele "Common Lisp: The Language" [CLtL1] Digital Press, 1984. 465 pages. ISBN 0-932376-41-X. 2. Guy L. Steele "Common Lisp: The Language, 2nd Edition" [CLtL2] Digital Press, 1990. 1029 pages. ISBN 1-55558-041-6. 3. Franz Inc. "Common Lisp: The Reference" Addison-Wesley, Reading, MA 1988. ISBN 0-201-11458-5 Entries on lisp functions in alphabetical order. 4. K. Dybvig. "The Scheme programming language" Prentice Hall, 1987. Good reference for Scheme. Lisp periodicals include: 1. LISP Pointers. Published by ACM SIGPLAN six times a year. Volume 1, Number 1 was April-May 1987. 2. LISP and Symbolic Computation, Kluwer Academic Press. Volume 1 was published in 1989. (jlz@lucid.com is the editor). ISSN 0892-4635. Subscriptions: Institutions $169; Individuals $80. Add $8 for air mail. Kluwer Academic Publishers, PO Box 322, 3300 AH Dordrecht, The Netherlands, or Kluwer Academic Publishers, PO Box 358, Accord Station, Hingham, MA 02018-0358. 3. Proceedings of the biannual ACM Lisp and Functional Programming Conference. (First one was in 1980.) 4. Proceedings of the annual Lisp Users and Vendors Conference. Implementation-specific questions: 1. Lucid. See the wizards.doc file that comes with the Lucid release. It describes functions, macros, variables and constants that are not official parts of the product and are not supported. Constructs described in this file include: the interrupt facility, the source file recording facility, the resource facility, multitasking, writing your own streams, lisp pipes, i/o buffers, the compiler, floating-point functions, memory management, debugger information, the window tool kit, extensions to the editor, the foreign function interface, clos information, delivery toolkit information, and Lucid lisp training classes. The wizards.doc file also covers i/o constructs, functions for dealing with DEFSTRUCT, functions and constants for dealing with procedure objects, functions and constants for dealing with code objects, function for mapping objects, additional keyword argument to DISKSAVE, function used in the implementation of arrays, function for monitor-specific behavior for a process, additional keyword argument to RUN-PROGRAM, and load-time evaluation. Introductions to Scheme (Many books on Scheme are worth reading even if you use Common Lisp, because many of the issues are similar): 1. Harold Abelson and Gerald Jay Sussman, with Julie Sussman. "Structure and Interpretation of Computer Programs" MIT Press (Cambridge, MA) and McGraw-Hill (New York), 1985. 542 pages. ISBN 0-262-01077-1 Starts off introductory, but rapidly gets into powerful Lisp-particular constructs, such as using closures and engines, building interpreters, compilers and object-oriented systems. 2. Daniel P. Friedman and M. Felleisen. "The Little LISPer" MIT Press (Cambridge, MA), 3rd printing, 1989. ISBN 0-262-56038-0. Science Research Associates (Chicago), 3rd ed, 1989. 206 pages. Good for a quick introduction. Uses Scheme instead of Common Lisp. (The book uses a dialect of Scheme with footnotes about translating to Scheme or Common Lisp. The footnotes won't allow a non-expert to use Common Lisp for the advanced chapters because of the complexity.) 3. George Springer and Daniel P. Friedman "Scheme and the Art of Programming" MIT Press and McGraw Hill, 1990, 596 pages. Introduces basic concepts of programming in Scheme. Also deals with object oriented programming, co-routining, continuations. Gives numerous examples. 4. Wolfgang Kreutzer and Bruce McKenzie "Programming for Artificial Intelligence: Methods, Tools and Applications" Addison-Wesley (Reading, MA), 1990. 682 pages. ISBN 0-201-41621-2. Discusses Scheme, Prolog, and Smalltalk, gives an overview of the history and philosophy of AI, surveys three major programming paradigms (procedural, declarative, and object-oriented), and metaphors to AI programming. 5. Smith "Introduction to Scheme" 1988. Focuses on PC Scheme. 6. Michael Eisenberg "Programming in Scheme" Scientific Press (Redwood City, CA), 1988. 304 pages. 7. The Ken Dickey article, "The Scheme Programming Language", in COMPUTER LANGUAGES magazine, and the Revised^4 Report on the Algorithmic Language Scheme, both of which are available by anonymous ftp from the scheme archive at nexus.yorku.ca. 8. Two articles in BYTE Magazine, February 1988, by Abelson and Sussman, and Clinger. 9. The Info files from the MIT Scheme implementation. Special Topics: Garbage Collection: Wilson, Paul R., "Uniprocessor Garbage Collection Techniques" Proceedings of the 1992 International Workshop on Memory Management. Surveys garbage collection techniques. Available by anonymous ftp from cs.utexas.edu:pub/garbage/gcsurvey.ps. Contact wilson@cs.utexas.edu for more info. ---------------------------------------------------------------- [1-2] How can I improve my Lisp programming style and coding efficiency? There are several books about Lisp programming style, including: 1. Molly M. Miller and Eric Benson "Lisp Style and Design" Digital Press, 1990. 214 pages. ISBN 1-55558-044-0. How to write large Lisp programs and improve Lisp programming style. Uses the development of Lucid CL as an example. 2. Robin Jones, Clive Maynard, and Ian Stewart. "The Art of Lisp Programming" Springer-Verlag, 1989. 169 pages. 3. W. Richard Stark. "LISP, Lore, and Logic: an algebraic view of LISP programming, foundations, and applications" Springer-Verlag, 1990. 278 pages. ISBN 0-387-97072-X Self-modifying code, self-reproducing programs, etc. 4. CMU CL User's Manual, Chapter 7, (talks about writing efficient code). It is available by anonymous ftp from any CMU CS machine (e.g., ftp.cs.cmu.edu [128.2.206.173]) as the file /afs/cs.cmu.edu/project/clisp/docs/cmu-user/cmu-user.ps [when getting this file by anonymous ftp, one must cd to the directory in one atomic operation, as some of the superior directories on the path are protected from access by anonymous ftp.] 5. See also Norvig's book, SICP (Abelson & Sussman), SAP (Springer and Friedman). 6. Hallvard Tretteberg's Lisp Style Guide is available by anonymous ftp in ftp.think.com:/public/think/lisp/style-guide.text. There is a fair bit of overlap between Hallvard's style guide and the notes below and in part 3 of this FAQ. Here are some general suggestions/notes about improving Lisp programming style, readability, correctness and efficiency: General Programming Style Rules: - Write short functions, where each function provides a single, well-defined operation. Small functions are easier to read, write, test, debug, and understand. - Use descriptive variable and function names. If it isn't clear from the name of a function or variable what its purpose is, document it with a documentation string and a comment. In fact, even if the purpose is evident from the name, it is still worth documenting your code. - Don't write Pascal (or C) code in Lisp. Use the appropriate predefined functions -- look in the index to CLtL2, or use the APROPOS and DESCRIBE functions. Don't put a close parenthesis on a line by itself -- this can really aggravate programmers who grew up on Lisp. Lisp-oriented text editors include tools for ensuring balanced parentheses and for moving across pairs of balanced parentheses. - Use proper indentation -- you should be able to understand the structure of your definitions without noticing the parentheses. The following functions often abused or misunderstood by novices. Think twice before using any of these functions. - EVAL. Novices almost always misuse EVAL. When experts use EVAL, they often would be better off using APPLY, FUNCALL, or SYMBOL-VALUE. Use of EVAL when defining a macro should set off a warning bell -- macro definitions are already evaluated during expansion. See also the answer to question 3-12.